home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / pascal / csdudes.exe / PDXFLD.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-27  |  14.7 KB  |  518 lines
  1. /*┌───────────────────────────────────────────────────────────────────────┐
  2.   │                                                                       │
  3.   │   Module:  PDXFLD.CPP                                                 │
  4.   │   Author:  Rick Kligman                                               │
  5.   │   Purpose: Source code for Field class                                │
  6.   │                                                                       │
  7.   │   Last Modified: 05-17-91 00:34am                                     │
  8.   │                                                                       │
  9.   │   Copyright 1991 Rick Kligman                                         │
  10.   │   This code may be freely used and distributed in commercial apps     │
  11.   │   provided some mention of PXBuddy++ is made in the documentation.    │
  12.   │                                                                       │
  13.   │   Version 1.00                                                        │
  14.   └───────────────────────────────────────────────────────────────────────┘ */
  15.  
  16. #include "pdxfld.hpp"
  17.  
  18. #ifndef   __STDIO_H
  19.   #include <stdio.h>
  20. #endif
  21.  
  22. #include "pdxtbl.hpp"
  23.  
  24. //    ╓───────────────────────────────────────────────────────────────╖
  25. //    ║                 Constructor for absfld class                  ║
  26. //    ╚═══════════════════════════════════════════════════════════════╝
  27.  
  28. absfld::absfld()
  29. {
  30. }
  31.  
  32. //    ╓───────────────────────────────────────────────────────────────╖
  33. //    ║                 Destructor  for absfld class                  ║
  34. //    ╚═══════════════════════════════════════════════════════════════╝
  35.  
  36. absfld::~absfld()
  37. {
  38. }
  39.  
  40. //    ╓───────────────────────────────────────────────────────────────╖
  41. //    ║                 Constructor for CharFld class                 ║
  42. //    ╚═══════════════════════════════════════════════════════════════╝
  43.  
  44. CharFld::CharFld()
  45. {
  46.   size = 0;
  47. }
  48.  
  49. //    ╓───────────────────────────────────────────────────────────────╖
  50. //    ║                 Destructor  for CharFld class                 ║
  51. //    ╚═══════════════════════════════════════════════════════════════╝
  52.  
  53. CharFld::~CharFld()
  54. {
  55.   if (size)
  56.       delete data;
  57. }
  58.  
  59. //    ╓─────────────────────────────────────────────────────────────╖
  60. //    ║                 Initialize CHAR Field                       ║
  61. //    ╚═════════════════════════════════════════════════════════════╝
  62.  
  63. int CharFld::setinfo(pxtable& tblptr, char *fldname)
  64. {
  65.   int     err;
  66.   char    fldtype [6];    // will hold len of field...A5, A23, A176 etc..
  67.  
  68.   tblp = &tblptr;
  69.  
  70.   err = PXFldHandle(tblp->th, fldname, &fh);
  71.   CKERR;
  72.  
  73.   err = PXFldType(tblp->th, fh, 6, fldtype);
  74.   CKERR;
  75.  
  76.   size = atoi(fldtype + 1) + 1;       // get len of field plus NULL char
  77.  
  78.   data = new char [size];             // allocate memory for var storage
  79.   if ( ! data )
  80.       return (PXERR_OUTOFMEM);
  81.  
  82.   return PXSUCCESS;
  83. }
  84.  
  85. //    ╓─────────────────────────────────────────────────────────────╖
  86. //    ║             Read CHAR Field from record buffer              ║
  87. //    ╚═════════════════════════════════════════════════════════════╝
  88.  
  89. int CharFld::get()
  90. {
  91.   int   blank;
  92.   int   err;
  93.  
  94.   err = PXFldBlank(tblp->rh, fh, &blank);
  95.   CKERR;
  96.  
  97.   if (blank)                                // char field was blank
  98.       data [0] = NULL;
  99.   else
  100.       err = PXGetAlpha(tblp->rh, fh, size, data);
  101.  
  102.   return (err);       // if no error then PXSUCCESS will be returned
  103. }
  104.  
  105.  
  106. // ╓─────────────────────────────────────────────────────────────────────────╖
  107. // ║                 Overload = to put contents into class                   ║
  108. // ╚═════════════════════════════════════════════════════════════════════════╝
  109.  
  110. void  CharFld::operator = (char *newval)
  111. {
  112.   strncpy(data, newval, size);
  113.   data [size - 1] = NULL;         // terminate the string
  114. }
  115.  
  116. //    ╓─────────────────────────────────────────────────────────────╖
  117. //    ║              Write CHAR Field to record buffer              ║
  118. //    ╚═════════════════════════════════════════════════════════════╝
  119.  
  120. int CharFld::put(int)
  121. {
  122.   int   err;
  123.  
  124.   err = PXPutAlpha(tblp->rh, fh, data);
  125.  
  126.   return (err);       // if no error then PXSUCCESS will be returned
  127. }
  128.  
  129. //    ╓─────────────────────────────────────────────────────────────╖
  130. //    ║                    Search a CHAR Field                      ║
  131. //    ╚═════════════════════════════════════════════════════════════╝
  132.  
  133. int CharFld::search(char *srchvar, int mode)
  134. {
  135.   int   err;
  136.   RECORDHANDLE  newrh;
  137.   PXNetTblRefresh(tblp->th);          // added by AFF for Network Support
  138.  
  139.   err = PXRecBufOpen(tblp->th, &newrh);
  140.   CKERR;
  141.  
  142.   err = PXRecBufEmpty(newrh);
  143.   CKERR;
  144.  
  145.   err = PXPutAlpha(newrh, fh, srchvar);
  146.   if ( err ) {
  147.         PXRecBufClose(newrh);
  148.         return err;
  149.   }
  150.  
  151.   err = search_fld(tblp->th, newrh, tblp->keyed, mode);
  152.  
  153.   PXRecBufClose(newrh);
  154.  
  155.   return (err);       // if no error then PXSUCCESS will be returned
  156. }
  157.  
  158. //    ╓───────────────────────────────────────────────────────────────╖
  159. //    ║                 Constructor for ShortFld class                ║
  160. //    ╚═══════════════════════════════════════════════════════════════╝
  161.  
  162. ShortFld::ShortFld()
  163. {
  164. }
  165.  
  166. //    ╓───────────────────────────────────────────────────────────────╖
  167. //    ║                 Destructor for ShortFld class                 ║
  168. //    ╚═══════════════════════════════════════════════════════════════╝
  169.  
  170. ShortFld::~ShortFld()
  171. {
  172. }
  173.  
  174.  
  175. //    ╓─────────────────────────────────────────────────────────────╖
  176. //    ║                 Initialize SHORT Field                      ║
  177. //    ╚═════════════════════════════════════════════════════════════╝
  178.  
  179. int ShortFld::setinfo(pxtable &tblptr, char *fldname)
  180. {
  181.   int     err;
  182.  
  183.   tblp = &tblptr;
  184.  
  185.   err = PXFldHandle(tblp->th, fldname, &fh);
  186.  
  187.   return (err);       // if no error then PXSUCCESS will be returned
  188. }
  189.  
  190. //    ╓─────────────────────────────────────────────────────────────╖
  191. //    ║             Read SHORT Field from record buffer             ║
  192. //    ╚═════════════════════════════════════════════════════════════╝
  193.  
  194. int ShortFld::get()
  195. {
  196.   int   blank;
  197.   int   err;
  198.  
  199.   err = PXFldBlank(tblp->rh, fh, &blank);
  200.   CKERR;
  201.  
  202.   if (blank)                          // short field was blank
  203.         data = 0;
  204.   else
  205.       err = PXGetShort(tblp->rh, fh, &data);
  206.  
  207.   return (err);       // if no error then PXSUCCESS will be returned
  208. }
  209.  
  210. //    ╓─────────────────────────────────────────────────────────────╖
  211. //    ║             Write SHORT Field to record buffer              ║
  212. //    ╚═════════════════════════════════════════════════════════════╝
  213.  
  214. int ShortFld::put(int blank)
  215. {
  216.   int   err;
  217.  
  218.   if ( data == 0 && blank )
  219.         err = PXPutBlank(tblp->rh, fh);
  220.   else
  221.       err = PXPutShort(tblp->rh, fh, data);
  222.  
  223.   return (err);       // if no error then PXSUCCESS will be returned
  224. }
  225.  
  226. //    ╓─────────────────────────────────────────────────────────────╖
  227. //    ║                   Search a SHORT Field                      ║
  228. //    ╚═════════════════════════════════════════════════════════════╝
  229.  
  230. int ShortFld::search(short srchvar, int mode)
  231. {
  232.   int   err;
  233.   RECORDHANDLE  newrh;
  234.  
  235.   PXNetTblRefresh(tblp->th);          // added by AFF for Network Support
  236.   err = PXRecBufOpen(tblp->th, &newrh);
  237.   CKERR;
  238.  
  239.   err = PXPutShort(newrh, fh, srchvar);
  240.   if ( err ) {
  241.         PXRecBufClose(newrh);
  242.         return err;
  243.   }
  244.  
  245.   err = search_fld(tblp->th, newrh, tblp->keyed, mode);
  246.  
  247.   PXRecBufClose(newrh);
  248.  
  249.   return (err);       // if no error then PXSUCCESS will be returned
  250. }
  251.  
  252. //    ╓───────────────────────────────────────────────────────────────╖
  253. //    ║                 Constructor for DblFld class                  ║
  254. //    ╚═══════════════════════════════════════════════════════════════╝
  255.  
  256. DblFld::DblFld()
  257. {
  258. }
  259.  
  260. //    ╓───────────────────────────────────────────────────────────────╖
  261. //    ║                 Destructor for DblFld class                   ║
  262. //    ╚═══════════════════════════════════════════════════════════════╝
  263.  
  264. DblFld::~DblFld()
  265. {
  266. }
  267.  
  268. //    ╓─────────────────────────────────────────────────────────────╖
  269. //    ║                 Initialize DOUBLE Field                     ║
  270. //    ╚═════════════════════════════════════════════════════════════╝
  271.  
  272. int DblFld::setinfo(pxtable &tblptr, char *fldname)
  273. {
  274.   int     err;
  275.  
  276.   tblp = &tblptr;
  277.  
  278.   err = PXFldHandle(tblp->th, fldname, &fh);
  279.  
  280.   return (err);       // if no error then PXSUCCESS will be returned
  281. }
  282.  
  283. //    ╓─────────────────────────────────────────────────────────────╖
  284. //    ║             Read DOUBLE Field from record buffer            ║
  285. //    ╚═════════════════════════════════════════════════════════════╝
  286.  
  287. int DblFld::get()
  288. {
  289.   int   blank;
  290.   int   err;
  291.  
  292.   err = PXFldBlank(tblp->rh, fh, &blank);
  293.   CKERR;
  294.  
  295.   if (blank)                          // double field was blank
  296.         data = 0;
  297.   else
  298.         err = PXGetDoub(tblp->rh, fh, &data);
  299.  
  300.   return (err);       // if no error then PXSUCCESS will be returned
  301. }
  302.  
  303. //    ╓─────────────────────────────────────────────────────────────╖
  304. //    ║             Write DOUBLE Field to record buffer             ║
  305. //    ╚═════════════════════════════════════════════════════════════╝
  306.  
  307.  
  308. int DblFld::put(int blank)
  309. {
  310.   int   err;
  311.  
  312.   if ( data == 0 && blank )
  313.         err = PXPutBlank(tblp->rh, fh);
  314.   else
  315.         err = PXPutDoub(tblp->rh, fh, data);
  316.  
  317.   return (err);       // if no error then PXSUCCESS will be returned
  318. }
  319.  
  320. //    ╓─────────────────────────────────────────────────────────────╖
  321. //    ║                   Search a DOUBLE Field                     ║
  322. //    ╚═════════════════════════════════════════════════════════════╝
  323.  
  324. int DblFld::search(double srchvar, int mode)
  325. {
  326.   int   err;
  327.   RECORDHANDLE  newrh;
  328.  
  329.   PXNetTblRefresh(tblp->th);          // added by AFF for Network Support
  330.   err = PXRecBufOpen(tblp->th, &newrh);
  331.   CKERR;
  332.  
  333.   err = PXPutDoub(newrh, fh, srchvar);
  334.   if ( err ) {
  335.         PXRecBufClose(newrh);
  336.         return err;
  337.   }
  338.  
  339.   err = search_fld(tblp->th, newrh, tblp->keyed, mode);
  340.  
  341.   PXRecBufClose(newrh);
  342.  
  343.   return (err);       // if no error then PXSUCCESS will be returned
  344. }
  345.  
  346. //    ╓───────────────────────────────────────────────────────────────╖
  347. //    ║                 Constructor for DateFld class                 ║
  348. //    ╚═══════════════════════════════════════════════════════════════╝
  349.  
  350. DateFld::DateFld()
  351. {
  352. }
  353.  
  354. //    ╓───────────────────────────────────────────────────────────────╖
  355. //    ║                 Destructor for DateFld class                  ║
  356. //    ╚═══════════════════════════════════════════════════════════════╝
  357.  
  358. DateFld::~DateFld()
  359. {
  360. }
  361.  
  362. //    ╓─────────────────────────────────────────────────────────────╖
  363. //    ║                 Initialize DATE Field                       ║
  364. //    ╚═════════════════════════════════════════════════════════════╝
  365.  
  366. int DateFld::setinfo(pxtable &tblptr, char *fldname)
  367. {
  368.   int     err;
  369.  
  370.   tblp = &tblptr;
  371.  
  372.   err = PXFldHandle(tblp->th, fldname, &fh);
  373.  
  374.   return (err);       // if no error then PXSUCCESS will be returned
  375. }
  376.  
  377. //    ╓─────────────────────────────────────────────────────────────╖
  378. //    ║             Read DATE Field from record buffer              ║
  379. //    ╚═════════════════════════════════════════════════════════════╝
  380.  
  381. int DateFld::get()
  382. {
  383.   int   blank;
  384.   int   err;
  385.   int   mo, da, yr;
  386.  
  387.   err = PXFldBlank(tblp->rh, fh, &blank);
  388.   CKERR;
  389.  
  390.   if (blank) {                        // date field was blank
  391.       strcpy(datastr, "");
  392.   }
  393.   else {
  394.         err = PXGetDate(tblp->rh, fh, &data);
  395.       CKERR;
  396.       PXDateDecode(data, &mo, &da, &yr);
  397.       yr -= 1900;
  398.       if ( yr < 0 )     // in case we get something we didn't expect!
  399.           yr = 0;
  400.       sprintf(datastr, "%.2i/%.2i/%.2i", mo, da, yr);
  401.   }
  402.  
  403.   return (err);       // if no error then PXSUCCESS will be returned
  404. }
  405.  
  406. //    ╓─────────────────────────────────────────────────────────────╖
  407. //    ║              Write DATE Field to record buffer              ║
  408. //    ╚═════════════════════════════════════════════════════════════╝
  409.  
  410. int DateFld::put(int)
  411. {
  412.   int   err;
  413.  
  414.   //  if the date is blank it can be one of two things. If the user never
  415.   //  enters the field then it will be NULL. If the user does go through
  416.   //  the field and leaves it blank, Vermont converts the date to 00/00/00
  417.  
  418.   if ( *datastr == NULL )
  419.       err = PXPutBlank(tblp->rh, fh);
  420.   else
  421.         err = PXPutDate(tblp->rh, fh, data);
  422.  
  423.   return (err);       // if no error then PXSUCCESS will be returned
  424. }
  425.  
  426. //    ╓─────────────────────────────────────────────────────────────╖
  427. //    ║          Search a DATE Field with CHAR String               ║
  428. //    ╚═════════════════════════════════════════════════════════════╝
  429. #if 0
  430. int DateFld::search(char *srchvar, int mode)
  431. {
  432.   int   err = -1;
  433.   RECORDHANDLE  newrh;
  434.  
  435.   PXNetTblRefresh(th);          // added by AFF for Network Support
  436.   err = PXRecBufOpen(tblp->th, &newrh);
  437.   CKERR;
  438.  
  439.   err = PXPutDate(newrh, fh, srchvar);
  440.   if ( err ) {
  441.       PXRecBufClose(newrh);
  442.       return err;
  443.   }
  444.  
  445.   err = search_fld(tblp->th, newrh, tblp->keyed, mode);
  446.  
  447.   PXRecBufClose(newrh);
  448.  
  449.   return (err);       // if no error then PXSUCCESS will be returned
  450. }
  451. #endif
  452.  
  453. //    ╓───────────────────────────────────────────────────────────╖
  454. //    ║                   Convert String to DATE                  ║
  455. //    ╚═══════════════════════════════════════════════════════════╝
  456.  
  457. int DateFld::operator = (char *newval)
  458. {
  459.   int   mo, da, yr, err;
  460.   char  temp [3];
  461.  
  462.   strncpy(datastr, newval, 11);
  463.   datastr [10] = NULL;
  464.  
  465.   temp [0] = *newval;
  466.   temp [1] = *(newval + 1);
  467.   temp [2] = NULL;
  468.  
  469.   mo = atoi(temp);
  470.  
  471.   temp [0] = *(newval + 3);
  472.   temp [1] = *(newval + 4);
  473.  
  474.   da = atoi(temp);
  475.  
  476.   temp [0] = *(newval + 6);
  477.   temp [1] = *(newval + 7);
  478.  
  479.   yr = atoi(temp);
  480.  
  481.   err = PXDateEncode(mo, da, yr, &data);
  482.  
  483.   return ( err );
  484. }
  485.  
  486. //    ╓───────────────────────────────────────────────────────────╖
  487. //    ║                       Search a Field                      ║
  488. //    ╚═══════════════════════════════════════════════════════════╝
  489.  
  490. int absfld::search_fld(TABLEHANDLE th, RECORDHANDLE rh, int keyed, int mode)
  491. {
  492.   int   err;
  493.  
  494.     if ((err = PXNetTblLock(th,WL)) != PXSUCCESS)
  495.         return(err);
  496.  
  497.     if ( ! keyed )          // non keyed searches need to go to top of table
  498.         PXRecGoto(th, 1);
  499.  
  500.   //  extra if on CLOSESTRECORD is done because even if it finds something
  501.   //  it will return RECNOTFOUND since it is an inexact match
  502.  
  503.   if ( fh == 1 && keyed )
  504.         err = PXSrchKey(th, rh, fh, mode);
  505.   else
  506.         err = PXSrchFld(th, rh, fh, mode);
  507.  
  508.     if (mode == CLOSESTRECORD && err == PXERR_RECNOTFOUND)
  509.         err = PXSUCCESS;
  510.  
  511.     PXNetTblUnlock(th,WL);
  512.  
  513.   return (err);       // if no error then PXSUCCESS will be returned
  514. }
  515.  
  516. // ===============================================================
  517.  
  518.